package com.huatai.saas.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huatai.common.entity.UserInfo;
import com.huatai.common.error.exception.ServiceException;
import com.huatai.common.util.AuthUtil;
import com.huatai.common.util.BeanUtil;
import com.huatai.common.util.PaginationUtils;
import com.huatai.common.util.StringUtil;
import com.huatai.saas.dto.OrderPageInfoListDto;
import com.huatai.saas.enums.OrderStatusEnum;
import com.huatai.saas.dto.SaveWorkingOrderDto;
import com.huatai.saas.dto.UpdateOrderForUserDto;
import com.huatai.saas.entity.WorkingOrderEntity;
import com.huatai.saas.mapper.WorkingOrderMapper;
import com.huatai.saas.service.WorkingOrderService;
import com.huatai.saas.vo.WorkingOrderListVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Locale;

/**
 * @program: nanming-saas
 * @description: 工单管理的业务逻辑层
 * @author: zcw
 * @create: 2024-04-10
 */
@Service
@Slf4j
public class WorkingOrderServiceImpl extends ServiceImpl<WorkingOrderMapper, WorkingOrderEntity> implements WorkingOrderService {

	/**
	 * 处理客户端新增工单的业务逻辑
	 * @param saveWorkingOrderDto 工单信息
	 * @return
	 */
	@Override
	public boolean saveOrder(SaveWorkingOrderDto saveWorkingOrderDto) {
		// 创建工单对象
		WorkingOrderEntity workingOrder = new WorkingOrderEntity();
		// 获取当前登录的用户
		UserInfo user = AuthUtil.getUser();
		/*UserInfo user = new UserInfo();
		user.setName("zcw");*/
		// 将saveWorkingOrderDto转为workingOrder
		BeanUtil.copyProperties(saveWorkingOrderDto, workingOrder);
		workingOrder
			// 设置工单编号
			.setOrderNumber(IdWorker.getMillisecond())
			// 设置用户id
			.setUserId(user.getUserId())
			// 设置用户名称
			.setUserName(user.getName())
			// 初始状态为未处理
			.setOrderStatus(OrderStatusEnum.UNTREATED.getCode())
			// 设置排序序号
			.setSort(99);
		// 向数据库中执行插入操作，返回影响的行数
		int row = baseMapper.insert(workingOrder);
		// 如果影响的行数不等于1，说明出现了异常
		if(row != 1){
			throw new ServiceException("新增工单异常，请稍后再试!");
		}
		return true;
	}

	/**
	 * 删除工单信息的业务逻辑
	 * @param orderId 工单id
	 * @return
	 */
	@Override
	public boolean delOrder(Long orderId) {
		//根据id查询该工单是否还存在
		WorkingOrderEntity order = baseMapper.selectById(orderId);
		//工单信息不存在
		if(order == null){
			throw new ServiceException("该工单信息不存在，删除工单失败！");
		}
		//工单信息存在，则开始删除操作,根据id删除，返回受影响的行数
		int row = baseMapper.deleteById(orderId);
		//如果影响的行数不等于1，说明删除过程中出现了异常
		if(row != 1){
			throw new ServiceException("删除工单异常，服务器忙，请稍后再试!");
		}
		return true;
	}

	/**
	 * 查询用户自己的工单信息列表
	 * 根据用户id查询对应的工单列表。
	 * 如果有工单状态编号，例如：未处理——0，处理中——1，已处理——2，则会对应的查询对应状态的工单信息
	 * 如果没有工单状态编号，则显示的工单信息列表中所有状态都有
	 * @param pageInfo 分页显示的参数
	 * @return
	 */
	@Override
	public IPage<WorkingOrderListVO> getUserWorkingOrderList(OrderPageInfoListDto pageInfo) {
		//设置分页参数
		Page<WorkingOrderListVO> page = PaginationUtils.getPage(
			//页码
			pageInfo.getPage(),
			//每页显示条数
			pageInfo.getSize()
		);
		//获取当前登录的用户
		UserInfo user = AuthUtil.getUser();
		/*UserInfo user = new UserInfo();
		user.setUserId(1706249133370699777L);*/
		//获取用户id
		Long userId = user.getUserId();
		//设置查询过滤条件
		LambdaQueryWrapper<WorkingOrderEntity> queryWrapper = new LambdaQueryWrapper<>();
		/*
		如果userId(用户id)不为null，则查到的数据是用户自己的工单数据
		 */
		queryWrapper.eq(!StringUtil.isEmpty(userId), WorkingOrderEntity::getUserId, userId);
		/*
		如果有工单状态编号，例如：未处理———0，处理中——1，已处理——2，则会对应的查询对应状态的工单信息
	    如果没有工单状态编号，则显示的工单信息列表中所有状态都有
		 */
		queryWrapper.eq(!StringUtil.isEmpty(pageInfo.getOrderStatus()), WorkingOrderEntity::getOrderStatus, pageInfo.getOrderStatus());
		/**
		 * 根据工单名称进行模糊查询
		 */
		queryWrapper.like(!StringUtil.isEmpty(pageInfo.getKeyWords()), WorkingOrderEntity::getChildName, pageInfo.getKeyWords());
		//数据持久层根据分页信息以及过滤条件去查询工单信息
		IPage<WorkingOrderListVO> workingOrderList =
			baseMapper.getOrderList(page, queryWrapper);
		return workingOrderList;
	}

	/**
	 * 查询所有用户的工单列表
	 * @param pageInfo
	 * @return
	 */
	@Override
	public IPage<WorkingOrderListVO> getAllWorkingOrderList(OrderPageInfoListDto pageInfo) {
		//设置分页参数
		Page<WorkingOrderListVO> page = PaginationUtils.getPage(
			//页码
			pageInfo.getPage(),
			//每页显示条数
			pageInfo.getSize()
		);
		//设置查询过滤条件
		LambdaQueryWrapper<WorkingOrderEntity> queryWrapper = new LambdaQueryWrapper<>();
		/*
		如果有工单状态编号，例如：未处理———0，处理中——1，已处理——2，则会对应的查询对应状态的工单信息
	    如果没有工单状态编号，则显示的工单信息列表中所有状态都有
		 */
		queryWrapper.eq(!StringUtil.isEmpty(pageInfo.getOrderStatus()), WorkingOrderEntity::getOrderStatus, pageInfo.getOrderStatus());
		/**
		 * 根据工单名称进行模糊查询
		 */
		queryWrapper.like(!StringUtil.isEmpty(pageInfo.getKeyWords()), WorkingOrderEntity::getChildName, pageInfo.getKeyWords());
		//数据持久层根据分页信息以及过滤条件去查询工单信息
		IPage<WorkingOrderListVO> workingOrderList =
			baseMapper.getOrderList(page, queryWrapper);
		return workingOrderList;
	}

	/**
	 * 客户端修改工单信息的处理逻辑
	 * @param updateOrderForUserDto 修改工单的信息
	 * @return
	 */
	@Override
	public boolean updateOrder(UpdateOrderForUserDto updateOrderForUserDto) {
		//查询要修改的工单是否还存在
		WorkingOrderEntity order = baseMapper.selectById(updateOrderForUserDto.getId());
		//如果工单不存在，修改不了
		if(order == null){
			throw new ServiceException("该工单信息不存在，修改工单失败！");
		}
		//如果工单存在且未处理，则可以进行修改操作
		WorkingOrderEntity workingOrder = new WorkingOrderEntity();
		//将updateOrderForUserDto转为workingOrder
		BeanUtil.copyProperties(updateOrderForUserDto, workingOrder);
		//开始修改操作，返回受影响的行数
		int row = baseMapper.updateById(workingOrder);
		//如果受影响的行数不唯1，说明修改异常
		if(row != 1){
			throw new ServiceException("修改工单异常，服务器忙，请稍后再试!");
		}
		return true;
	}

	/**
	 * 处理工单状态：未处理
	 * @param id 工单id
	 * @return
	 */
	@Override
	public boolean setUntreated(Long id) {
		return setStatus(id, OrderStatusEnum.UNTREATED.getCode());
	}

	/**
	 * 处理工单状态：处理中
	 * @param id 工单id
	 * @return
	 */
	@Override
	public boolean setHandling(Long id) {
		return setStatus(id, OrderStatusEnum.HANDLING.getCode());
	}

	/**
	 * 处理工单状态：已处理
	 * @param id 工单id
	 * @return
	 */
	@Override
	public boolean setProcessed(Long id) {
		return setStatus(id, OrderStatusEnum.PROCESSED.getCode());
	}

	/**
	 * 处理工单状态的业务逻辑
	 * @param id 工单id
	 * @param statusCode 状态编码
	 * @return
	 */
	private boolean setStatus(Long id, Integer statusCode){
		//查询工单信息是否存在
		WorkingOrderEntity order = baseMapper.selectById(id);
		//为null，说明工单信息不存在
		if(order == null){
			throw new ServiceException("该工单信息不存在，修改状态失败！");
		}
		UserInfo user = AuthUtil.getUser();
		/*UserInfo user = new UserInfo();
		user.setAccount("admin");
		user.setRealName("admin");*/
		order
			// 将工单信息修改为已处理
			.setOrderStatus(statusCode)
			// 设置处理人的账号
			.setAccount(user.getAccount())
			// 设置处理人的名字
			.setProcessName(user.getRealName());
		//数据持久层修改信息，返回受影响的行数
		int row = baseMapper.updateById(order);
		//如果影响的行数不为1，则出现异常
		if(row != 1){
			throw new ServiceException("修改工单状态异常，请稍后再试！");
		}
		return true;
	}


}
